home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Interfaces&Libraries / Universal / Interfaces / PInterfaces / CardServices.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  31.2 KB  |  919 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        CardServices.p
  3.  
  4.      Contains:    The client interface to Card and Socket Services.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1994-1998 by Apple Computer, Inc. All rights reserved.
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT CardServices;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __CARDSERVICES__}
  27. {$SETC __CARDSERVICES__ := 1}
  28.  
  29. {$I+}
  30. {$SETC CardServicesIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __MACTYPES__}
  34. {$I MacTypes.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __PCCARDTUPLES__}
  37. {$I PCCardTuples.p}
  38. {$ENDC}
  39. {$IFC UNDEFINED __MIXEDMODE__}
  40. {$I MixedMode.p}
  41. {$ENDC}
  42.  
  43.  
  44. {$PUSH}
  45. {$ALIGN MAC68K}
  46. {$LibExport+}
  47.  
  48. {     miscellaneous }
  49.  
  50.  
  51. CONST
  52.     CS_MAX_SOCKETS                = 32;                            {  a long is used as a socket bitmap }
  53.  
  54.  
  55. {  Will move to <Traps.h> }
  56.     _PCCardDispatch                = $AAF0;                        {  Card Services entry trap }
  57.  
  58. {  Will move to <Errors.h> }
  59.  
  60. {     result codes }
  61.  
  62.     kCSBadAdapterErr            = -9050;                        {  invalid adapter number }
  63.     kCSBadAttributeErr            = -9051;                        {  specified attributes field value is invalid }
  64.     kCSBadBaseErr                = -9052;                        {  specified base system memory address is invalid }
  65.     kCSBadEDCErr                = -9053;                        {  specified EDC generator specified is invalid }
  66.     kCSBadIRQErr                = -9054;                        {  specified IRQ level is invalid }
  67.     kCSBadOffsetErr                = -9055;                        {  specified PC card memory array offset is invalid }
  68.     kCSBadPageErr                = -9056;                        {  specified page is invalid }
  69.     kCSBadSizeErr                = -9057;                        {  specified size is invalid }
  70.     kCSBadSocketErr                = -9058;                        {  specified logical or physical socket number is invalid }
  71.     kCSBadTypeErr                = -9059;                        {  specified window or interface type is invalid }
  72.     kCSBadVccErr                = -9060;                        {  specified Vcc power level index is invalid }
  73.     kCSBadVppErr                = -9061;                        {  specified Vpp1 or Vpp2 power level index is invalid }
  74.     kCSBadWindowErr                = -9062;                        {  specified window is invalid }
  75.     kCSBadArgLengthErr            = -9063;                        {  ArgLength argument is invalid }
  76.     kCSBadArgsErr                = -9064;                        {  values in argument packet are invalid }
  77.     kCSBadHandleErr                = -9065;                        {  clientHandle is invalid }
  78.     kCSBadCISErr                = -9066;                        {  CIS on card is invalid }
  79.     kCSBadSpeedErr                = -9067;                        {  specified speed is unavailable }
  80.     kCSReadFailureErr            = -9068;                        {  unable to complete read request }
  81.     kCSWriteFailureErr            = -9069;                        {  unable to complete write request }
  82.     kCSGeneralFailureErr        = -9070;                        {  an undefined error has occurred }
  83.     kCSNoCardErr                = -9071;                        {  no PC card in the socket }
  84.     kCSUnsupportedFunctionErr    = -9072;                        {  function is not supported by this implementation }
  85.     kCSUnsupportedModeErr        = -9073;                        {  mode is not supported }
  86.     kCSBusyErr                    = -9074;                        {  unable to process request at this time - try later }
  87.     kCSWriteProtectedErr        = -9075;                        {  media is write-protected }
  88.     kCSConfigurationLockedErr    = -9076;                        {  a configuration has already been locked }
  89.     kCSInUseErr                    = -9077;                        {  requested resource is being used by a client }
  90.     kCSNoMoreItemsErr            = -9078;                        {  there are no more of the requested item }
  91.     kCSOutOfResourceErr            = -9079;                        {  Card Services has exhausted the resource }
  92.  
  93.  
  94.  
  95. {     messages sent to client's event handler }
  96.  
  97.     kCSNullMessage                = $00;                            {  no messages pending (not sent to clients) }
  98.     kCSCardInsertionMessage        = $01;                            {  card has been inserted into the socket }
  99.     kCSCardRemovalMessage        = $02;                            {  card has been removed from the socket }
  100.     kCSCardLockMessage            = $03;                            {  card is locked into the socket with a mechanical latch }
  101.     kCSCardUnlockMessage        = $04;                            {  card is no longer locked into the socket }
  102.     kCSCardReadyMessage            = $05;                            {  card is ready to be accessed }
  103.     kCSCardResetMessage            = $06;                            {  physical reset has completed }
  104.     kCSInsertionRequestMessage    = $07;                            {  request to insert a card using insertion motor }
  105.     kCSInsertionCompleteMessage    = $08;                            {  insertion motor has finished inserting a card }
  106.     kCSEjectionRequestMessage    = $09;                            {  user or other client is requesting a card ejection }
  107.     kCSEjectionFailedMessage    = $0A;                            {  eject failure due to electrical/mechanical problems }
  108.     kCSPMResumeMessage            = $0B;                            {  power management resume (TBD) }
  109.     kCSPMSuspendMessage            = $0C;                            {  power management suspend (TBD) }
  110.     kCSResetPhysicalMessage        = $0D;                            {  physical reset is about to occur on this card }
  111.     kCSResetRequestMessage        = $0E;                            {  physical reset has been requested by a client }
  112.     kCSResetCompleteMessage        = $0F;                            {  ResetCard() background reset has completed }
  113.     kCSBatteryDeadMessage        = $10;                            {  battery is no longer useable, data will be lost }
  114.     kCSBatteryLowMessage        = $11;                            {  battery is weak and should be replaced }
  115.     kCSWriteProtectMessage        = $12;                            {  card is now write protected }
  116.     kCSWriteEnabledMessage        = $13;                            {  card is now write enabled }
  117.     kCSClientInfoMessage        = $14;                            {  client is to return client information }
  118.     kCSSSUpdatedMessage            = $15;                            {  AddSocketServices/ReplaceSocket services has changed SS support }
  119.     kCSFunctionInterruptMessage    = $16;                            {  card function interrupt }
  120.     kCSAccessErrorMessage        = $17;                            {  client bus errored on access to socket }
  121.     kCSCardUnconfiguredMessage    = $18;                            {  a CARD_READY was delivered to all clients and no client  }
  122.                                                                 {     requested a configuration for the socket }
  123.     kCSStatusChangedMessage        = $19;                            {  status change for cards in I/O mode }
  124.  
  125. {
  126.     The following is a mapping of the PCMCIA name space to the Macintosh name space.
  127.     These two enum lists will be removed and given to developers as a separate file.
  128. }
  129.     SUCCESS                        = 0;
  130.     BAD_ADAPTER                    = -9050;
  131.     BAD_ATTRIBUTE                = -9051;
  132.     BAD_BASE                    = -9052;
  133.     BAD_EDC                        = -9053;
  134.     BAD_IRQ                        = -9054;
  135.     BAD_OFFSET                    = -9055;
  136.     BAD_PAGE                    = -9056;
  137.     BAD_SIZE                    = -9057;
  138.     BAD_SOCKET                    = -9058;
  139.     BAD_TYPE                    = -9059;
  140.     BAD_VCC                        = -9060;
  141.     BAD_VPP                        = -9061;
  142.     BAD_WINDOW                    = -9062;
  143.     BAD_ARG_LENGTH                = -9063;
  144.     BAD_ARGS                    = -9064;
  145.     BAD_HANDLE                    = -9065;
  146.     BAD_CIS                        = -9066;
  147.     BAD_SPEED                    = -9067;
  148.     READ_FAILURE                = -9068;
  149.     WRITE_FAILURE                = -9069;
  150.     GENERAL_FAILURE                = -9070;
  151.     NO_CARD                        = -9071;
  152.     UNSUPPORTED_FUNCTION        = -9072;
  153.     UNSUPPORTED_MODE            = -9073;
  154.     BUSY                        = -9074;
  155.     WRITE_PROTECTED                = -9075;
  156.     CONFIGURATION_LOCKED        = -9076;
  157.     IN_USE                        = -9077;
  158.     NO_MORE_ITEMS                = -9078;
  159.     OUT_OF_RESOURCE                = -9079;
  160.  
  161.  
  162. {     messages sent to client's event handler }
  163.  
  164.     NULL_MESSAGE                = $00;
  165.     CARD_INSERTION                = $01;
  166.     CARD_REMOVAL                = $02;
  167.     CARD_LOCK                    = $03;
  168.     CARD_UNLOCK                    = $04;
  169.     CARD_READY                    = $05;
  170.     CARD_RESET                    = $06;
  171.     INSERTION_REQUEST            = $07;
  172.     INSERTION_COMPLETE            = $08;
  173.     EJECTION_REQUEST            = $09;
  174.     EJECTION_FAILED                = $0A;
  175.     PM_RESUME                    = $0B;
  176.     PM_SUSPEND                    = $0C;
  177.     RESET_PHYSICAL                = $0D;
  178.     RESET_REQUEST                = $0E;
  179.     RESET_COMPLETE                = $0F;
  180.     BATTERY_DEAD                = $10;
  181.     BATTERY_LOW                    = $11;
  182.     WRITE_PROTECT                = $12;
  183.     WRITE_ENABLED                = $13;
  184.     CLIENT_INFO                    = $14;
  185.     SS_UPDATED                    = $15;
  186.     FUNCTION_INTERRUPT            = $16;
  187.     ACCESS_ERROR                = $17;
  188.     CARD_UNCONFIGURED            = $18;
  189.     STATUS_CHANGED                = $19;
  190.  
  191.  
  192. { ----------------        CSAccessConfigurationRegister    ---------------- }
  193.  
  194.  
  195. TYPE
  196.     AccessConfigurationRegisterPBPtr = ^AccessConfigurationRegisterPB;
  197.     AccessConfigurationRegisterPB = RECORD
  198.         socket:                    UInt16;                                    {   -> global socket number }
  199.         action:                    SInt8;                                    {   -> read/write }
  200.         offset:                    SInt8;                                    {   -> offset from config register base }
  201.         value:                    SInt8;                                    {  <-> value to read/write }
  202.         padding:                SInt8;                                    {   }
  203.     END;
  204.  
  205. {     ‘action’ field values }
  206.  
  207.  
  208. CONST
  209.     kCSReadConfigRegister        = $00;
  210.     kCSWriteConfigRegister        = $01;
  211.  
  212.  
  213. { ----------------        CSGetCardServicesInfo            ---------------- }
  214.  
  215.  
  216. TYPE
  217.     GetCardServicesInfoPBPtr = ^GetCardServicesInfoPB;
  218.     GetCardServicesInfoPB = RECORD
  219.         signature:                PACKED ARRAY [0..1] OF UInt8;            {  <-  two ascii chars 'CS' }
  220.         count:                    UInt16;                                    {  <-  total number of sockets installed }
  221.         revision:                UInt16;                                    {  <-  BCD }
  222.         csLevel:                UInt16;                                    {  <-  BCD }
  223.         reserved:                UInt16;                                    {   -> zero }
  224.         vStrLen:                UInt16;                                    {  <-> in: client's buffer size, out: vendor string length }
  225.         vendorString:            Ptr;                                    {  <-> in: pointer to buffer to hold CS vendor string (zero-terminated) }
  226.                                                                         {       out: CS vendor string copied to buffer }
  227.     END;
  228.  
  229. { ----------------        CSGetClientInfo                    ---------------- }
  230.  
  231.  
  232. {  upper byte of attributes is kCSClientInfoSubfunction }
  233.     ClientInfoParamPtr = ^ClientInfoParam;
  234.     ClientInfoParam = RECORD
  235.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  236.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  237.         revision:                UInt16;                                    {  <-  BCD value of client's revision }
  238.         csLevel:                UInt16;                                    {  <-  BCD value of CS release }
  239.         revDate:                UInt16;                                    {  <-  revision date: y[15-9], m[8-5], d[4-0] }
  240.         nameLen:                SInt16;                                    {  <-> in: max length of client name string, out: actual length }
  241.         vStringLen:                SInt16;                                    {  <-> in: max length of vendor string, out: actual length }
  242.         nameString:                Ptr;                                    {  <-  pointer to client name string (zero-terminated) }
  243.         vendorString:            Ptr;                                    {  <-  pointer to vendor string (zero-terminated) }
  244.     END;
  245.  
  246. {
  247.    upper byte of attributes is kCSCardNameSubfunction,
  248.                                  kCSCardTypeSubfunction,
  249.                                  kCSHelpStringSubfunction
  250. }
  251.     AlternateTextStringParamPtr = ^AlternateTextStringParam;
  252.     AlternateTextStringParam = RECORD
  253.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  254.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  255.         socket:                    UInt16;                                    {   -> logical socket number }
  256.         reserved:                UInt16;                                    {   -> zero }
  257.         length:                    SInt16;                                    {  <-> in: max length of string, out: actual length }
  258.         text:                    Ptr;                                    {  <-  pointer to string (zero-terminated) }
  259.     END;
  260.  
  261. {  upper byte of attributes is kCSCardIconSubfunction }
  262.     AlternateCardIconParamPtr = ^AlternateCardIconParam;
  263.     AlternateCardIconParam = RECORD
  264.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  265.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  266.         socket:                    UInt16;                                    {   -> logical socket number }
  267.         iconSuite:                Handle;                                    {  <-  handle to icon suite containing all icons }
  268.     END;
  269.  
  270. {  upper byte of attributes is kCSActionProcSubfunction }
  271.     CustomActionProcParamPtr = ^CustomActionProcParam;
  272.     CustomActionProcParam = RECORD
  273.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  274.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  275.         socket:                    UInt16;                                    {   -> logical socket number }
  276.     END;
  277.  
  278.     GetClientInfoPBPtr = ^GetClientInfoPB;
  279.     GetClientInfoPB = RECORD
  280.         CASE INTEGER OF
  281.         0: (
  282.             clientInfo:            ClientInfoParam;
  283.             );
  284.         1: (
  285.             alternateTextString: AlternateTextStringParam;
  286.             );
  287.         2: (
  288.             alternateIcon:        AlternateCardIconParam;
  289.             );
  290.         3: (
  291.             customActionProc:    CustomActionProcParam;
  292.             );
  293.     END;
  294.  
  295. {     ‘attributes’ field values }
  296.  
  297. CONST
  298.     kCSMemoryClient                = $0001;
  299.     kCSIOClient                    = $0004;
  300.     kCSClientTypeMask            = $0007;
  301.     kCSShareableCardInsertEvents = $0008;
  302.     kCSExclusiveCardInsertEvents = $0010;
  303.     kCSInfoSubfunctionMask        = $FF00;
  304.     kCSClientInfoSubfunction    = $0000;
  305.     kCSCardNameSubfunction        = $8000;
  306.     kCSCardTypeSubfunction        = $8100;
  307.     kCSHelpStringSubfunction    = $8200;
  308.     kCSCardIconSubfunction        = $8300;
  309.     kCSActionProcSubfunction    = $8400;
  310.  
  311.  
  312. {
  313.   ----------------        CSGetConfigurationInfo            ----------------
  314.   ----------------        CSModifyConfiguration            ----------------
  315.   ----------------        CSRequestConfiguration            ----------------
  316. }
  317.  
  318.  
  319. TYPE
  320.     GetModRequestConfigInfoPBPtr = ^GetModRequestConfigInfoPB;
  321.     GetModRequestConfigInfoPB = RECORD
  322.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  323.         socket:                    UInt16;                                    {   -> logical socket number }
  324.         attributes:                UInt16;                                    {  <-> bitmap of configuration attributes }
  325.         vcc:                    SInt8;                                    {  <-> Vcc setting }
  326.         vpp1:                    SInt8;                                    {  <-> Vpp1 setting }
  327.         vpp2:                    SInt8;                                    {  <-> Vpp2 setting }
  328.         intType:                SInt8;                                    {  <-> interface type (memory or memory+I/O) }
  329.         configBase:                UInt32;                                    {  <-> card base address of configuration registers }
  330.         status:                    SInt8;                                    {  <-> card status register setting, if present }
  331.         pin:                    SInt8;                                    {  <-> card pin register setting, if present }
  332.         copy:                    SInt8;                                    {  <-> card socket/copy register setting, if present }
  333.         configIndex:            SInt8;                                    {  <-> card option register setting, if present }
  334.         present:                SInt8;                                    {  <-> bitmap of which configuration registers are present }
  335.         firstDevType:            SInt8;                                    {  <-  from DeviceID tuple }
  336.         funcCode:                SInt8;                                    {  <-  from FuncID tuple }
  337.         sysInitMask:            SInt8;                                    {  <-  from FuncID tuple }
  338.         manufCode:                UInt16;                                    {  <-  from ManufacturerID tuple }
  339.         manufInfo:                UInt16;                                    {  <-  from ManufacturerID tuple }
  340.         cardValues:                SInt8;                                    {  <-  valid card register values }
  341.         padding:                SInt8;                                    {   }
  342.     END;
  343.  
  344. {     ‘attributes’ field values }
  345.  
  346. CONST
  347.     kCSExclusivelyUsed            = $0001;
  348.     kCSEnableIREQs                = $0002;
  349.     kCSVccChangeValid            = $0004;
  350.     kCSVpp1ChangeValid            = $0008;
  351.     kCSVpp2ChangeValid            = $0010;
  352.     kCSValidClient                = $0020;
  353.     kCSSleepPower                = $0040;                        {  request that power be applied to socket during Sleep }
  354.     kCSLockSocket                = $0080;
  355.     kCSTurnOnInUse                = $0100;
  356.  
  357. {     ‘intType’ field values }
  358.  
  359.     kCSMemoryInterface            = $01;
  360.     kCSMemory_And_IO_Interface    = $02;
  361.  
  362. {     ‘present’ field values }
  363.  
  364.     kCSOptionRegisterPresent    = $01;
  365.     kCSStatusRegisterPresent    = $02;
  366.     kCSPinReplacementRegisterPresent = $04;
  367.     kCSCopyRegisterPresent        = $08;
  368.  
  369. {     ‘cardValues’ field values }
  370.  
  371.     kCSOptionValueValid            = $01;
  372.     kCSStatusValueValid            = $02;
  373.     kCSPinReplacementValueValid    = $04;
  374.     kCSCopyValueValid            = $08;
  375.  
  376.  
  377. {
  378.   ----------------        CSGetClientEventMask            ----------------
  379.   ----------------        CSSetClientEventMask            ----------------
  380. }
  381.  
  382.  
  383. TYPE
  384.     GetSetClientEventMaskPBPtr = ^GetSetClientEventMaskPB;
  385.     GetSetClientEventMaskPB = RECORD
  386.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  387.         attributes:                UInt16;                                    {  <-> bitmap of attributes }
  388.         eventMask:                UInt16;                                    {  <-> bitmap of events to be passed to client for this socket }
  389.         socket:                    UInt16;                                    {   -> logical socket number }
  390.     END;
  391.  
  392. {     ‘attributes’ field values }
  393.  
  394. CONST
  395.     kCSEventMaskThisSocketOnly    = $0001;
  396.  
  397. {     ‘eventMask’ field values }
  398.  
  399.     kCSWriteProtectEvent        = $0001;
  400.     kCSCardLockChangeEvent        = $0002;
  401.     kCSEjectRequestEvent        = $0004;
  402.     kCSInsertRequestEvent        = $0008;
  403.     kCSBatteryDeadEvent            = $0010;
  404.     kCSBatteryLowEvent            = $0020;
  405.     kCSReadyChangeEvent            = $0040;
  406.     kCSCardDetectChangeEvent    = $0080;
  407.     kCSPMChangeEvent            = $0100;
  408.     kCSResetEvent                = $0200;
  409.     kCSSSUpdateEvent            = $0400;
  410.     kCSFunctionInterrupt        = $0800;
  411.     kCSAllEvents                = $FFFF;
  412.  
  413.  
  414. {
  415.   ----------------        CSGetFirstClient                ----------------
  416.   ----------------        CSGetNextClient                    ----------------
  417. }
  418.  
  419.  
  420. TYPE
  421.     GetClientPBPtr = ^GetClientPB;
  422.     GetClientPB = RECORD
  423.         clientHandle:            UInt32;                                    {  <-  clientHandle for this client }
  424.         socket:                    UInt16;                                    {   -> logical socket number }
  425.         attributes:                UInt16;                                    {   -> bitmap of attributes }
  426.     END;
  427.  
  428. {     ‘attributes’ field values }
  429.  
  430. CONST
  431.     kCSClientsForAllSockets        = $0000;
  432.     kCSClientsThisSocketOnly    = $0001;
  433.  
  434.  
  435. {
  436.   ----------------        CSGetFirstTuple                    ----------------
  437.   ----------------        CSGetNextTuple                    ----------------
  438.   ----------------        CSGetTupleData                    ----------------
  439. }
  440.  
  441.  
  442. TYPE
  443.     GetTuplePBPtr = ^GetTuplePB;
  444.     GetTuplePB = RECORD
  445.         socket:                    UInt16;                                    {   -> logical socket number }
  446.         attributes:                UInt16;                                    {   -> bitmap of attributes }
  447.         desiredTuple:            SInt8;                                    {   -> desired tuple code value, or $FF for all }
  448.         tupleOffset:            SInt8;                                    {   -> offset into tuple from link byte }
  449.         flags:                    UInt16;                                    {  <-> internal use }
  450.         linkOffset:                UInt32;                                    {  <-> internal use }
  451.         cisOffset:                UInt32;                                    {  <-> internal use }
  452.         CASE INTEGER OF
  453.         0: (
  454.             tupleCode:            SInt8;                                    {  <-  tuple code found }
  455.             tupleLink:            SInt8;                                    {  <-  link value for tuple found }
  456.            );
  457.         1: (
  458.             tupleDataMax:        UInt16;                                    {   -> maximum size of tuple data area }
  459.             tupleDataLen:        UInt16;                                    {  <-  number of bytes in tuple body }
  460.             tupleData:            TupleBody;                                {  <-  tuple data }
  461.            );
  462.     END;
  463.  
  464. {     ‘attributes’ field values }
  465.  
  466. CONST
  467.     kCSReturnLinkTuples            = $0001;
  468.  
  469.  
  470. {
  471.   ----------------        CSRequestSocketMask                ----------------
  472.   ----------------        CSReleaseSocketMask                ----------------
  473. }
  474.  
  475.  
  476. TYPE
  477.     ReqRelSocketMaskPBPtr = ^ReqRelSocketMaskPB;
  478.     ReqRelSocketMaskPB = RECORD
  479.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  480.         socket:                    UInt16;                                    {   -> logical socket }
  481.         eventMask:                UInt16;                                    {   -> bitmap of events to be passed to client for this socket }
  482.     END;
  483.  
  484. {     ‘eventMask’ field values (see above for Get/SetClientEventMask }
  485.  
  486. { ----------------        CSGetStatus                        ---------------- }
  487.  
  488.     GetStatusPBPtr = ^GetStatusPB;
  489.     GetStatusPB = RECORD
  490.         socket:                    UInt16;                                    {   -> logical socket number }
  491.         cardState:                UInt16;                                    {  <-  current state of installed card }
  492.         socketState:            UInt16;                                    {  <-  current state of the socket }
  493.     END;
  494.  
  495. {     ‘cardState’ field values }
  496.  
  497. CONST
  498.     kCSWriteProtected            = $0001;
  499.     kCSCardLocked                = $0002;
  500.     kCSEjectRequest                = $0004;
  501.     kCSInsertRequest            = $0008;
  502.     kCSBatteryDead                = $0010;
  503.     kCSBatteryLow                = $0020;
  504.     kCSReady                    = $0040;
  505.     kCSCardDetected                = $0080;
  506.  
  507. {     ‘socketState’ field values }
  508.  
  509.     kCSWriteProtectChanged        = $0001;
  510.     kCSCardLockChanged            = $0002;
  511.     kCSEjectRequestPending        = $0004;
  512.     kCSInsertRequestPending        = $0008;
  513.     kCSBatteryDeadChanged        = $0010;
  514.     kCSBatteryLowChanged        = $0020;
  515.     kCSReadyChanged                = $0040;
  516.     kCSCardDetectChanged        = $0080;
  517.  
  518.  
  519. {
  520.   ----------------        CSModifyWindow                    ----------------
  521.   ----------------        CSReleaseWindow                    ----------------
  522.   ----------------        CSRequestWindow                    ----------------
  523. }
  524.  
  525.  
  526. TYPE
  527.     ReqModRelWindowPBPtr = ^ReqModRelWindowPB;
  528.     ReqModRelWindowPB = RECORD
  529.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  530.         windowHandle:            UInt32;                                    {  <-> window descriptor }
  531.         socket:                    UInt16;                                    {   -> logical socket number }
  532.         attributes:                UInt16;                                    {   -> window attributes (bitmap) }
  533.         base:                    UInt32;                                    {  <-> system base address }
  534.         size:                    UInt32;                                    {  <-> memory window size }
  535.         accessSpeed:            SInt8;                                    {   -> window access speed (bitmap) }
  536.                                                                         {         (not applicable for I/O mode) }
  537.         padding:                SInt8;                                    {   }
  538.     END;
  539.  
  540. {     ‘attributes’ field values }
  541.  
  542. CONST
  543.     kCSMemoryWindow                = $0001;
  544.     kCSIOWindow                    = $0002;
  545.     kCSAttributeWindow            = $0004;                        {  not normally used by Card Services clients }
  546.     kCSWindowTypeMask            = $0007;
  547.     kCSEnableWindow                = $0008;
  548.     kCSAccessSpeedValid            = $0010;
  549.     kCSLittleEndian                = $0020;                        {  configure socket for little endianess }
  550.     kCS16BitDataPath            = $0040;
  551.     kCSWindowPaged                = $0080;                        {   }
  552.     kCSWindowShared                = $0100;
  553.     kCSWindowFirstShared        = $0200;                        {   }
  554.     kCSWindowProgrammable        = $0400;                        {   }
  555.  
  556. {     ‘accessSpeed’ field values }
  557.  
  558.     kCSDeviceSpeedCodeMask        = $07;
  559.     kCSSpeedExponentMask        = $07;
  560.     kCSSpeedMantissaMask        = $78;
  561.     kCSUseWait                    = $80;
  562.     kCSAccessSpeed250nsec        = $01;
  563.     kCSAccessSpeed200nsec        = $02;
  564.     kCSAccessSpeed150nsec        = $03;
  565.     kCSAccessSpeed100nsec        = $04;
  566.     kCSExtAccSpeedMant1pt0        = $01;
  567.     kCSExtAccSpeedMant1pt2        = $02;
  568.     kCSExtAccSpeedMant1pt3        = $03;
  569.     kCSExtAccSpeedMant1pt5        = $04;
  570.     kCSExtAccSpeedMant2pt0        = $05;
  571.     kCSExtAccSpeedMant2pt5        = $06;
  572.     kCSExtAccSpeedMant3pt0        = $07;
  573.     kCSExtAccSpeedMant3pt5        = $08;
  574.     kCSExtAccSpeedMant4pt0        = $09;
  575.     kCSExtAccSpeedMant4pt5        = $0A;
  576.     kCSExtAccSpeedMant5pt0        = $0B;
  577.     kCSExtAccSpeedMant5pt5        = $0C;
  578.     kCSExtAccSpeedMant6pt0        = $0D;
  579.     kCSExtAccSpeedMant7pt0        = $0E;
  580.     kCSExtAccSpeedMant8pt0        = $0F;
  581.     kCSExtAccSpeedExp1ns        = $00;
  582.     kCSExtAccSpeedExp10ns        = $01;
  583.     kCSExtAccSpeedExp100ns        = $02;
  584.     kCSExtAccSpeedExp1us        = $03;
  585.     kCSExtAccSpeedExp10us        = $04;
  586.     kCSExtAccSpeedExp100us        = $05;
  587.     kCSExtAccSpeedExp1ms        = $06;
  588.     kCSExtAccSpeedExp10ms        = $07;
  589.  
  590.  
  591. {
  592.   ----------------        CSRegisterClient                ----------------
  593.   ----------------        CSDeregisterClient                ----------------
  594. }
  595.  
  596.  
  597. TYPE
  598.     ClientCallbackPBPtr = ^ClientCallbackPB;
  599.     ClientCallbackPB = RECORD
  600.         message:                UInt16;                                    {   -> which event this is }
  601.         socket:                    UInt16;                                    {   -> logical socket number }
  602.         info:                    UInt16;                                    {   -> function-specific }
  603.         misc:                    UInt16;                                    {   -> function-specific }
  604.         reserved:                Ptr;                                    {   -> pointer to MTD request block }
  605.         buffer:                    Ptr;                                    {   -> function-specific }
  606.         clientData:                Ptr;                                    {   -> pointer to client's data (from RegisterClient) }
  607.     END;
  608.  
  609. {$IFC TYPED_FUNCTION_POINTERS}
  610.     PCCardCSClientProcPtr = FUNCTION(ccPBPtr: ClientCallbackPBPtr): UInt16;
  611. {$ELSEC}
  612.     PCCardCSClientProcPtr = ProcPtr;
  613. {$ENDC}
  614.  
  615.     PCCardCSClientUPP = UniversalProcPtr;
  616.  
  617. CONST
  618.     uppPCCardCSClientProcInfo = $000000E0;
  619.  
  620. FUNCTION NewPCCardCSClientProc(userRoutine: PCCardCSClientProcPtr): PCCardCSClientUPP;
  621.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  622.     INLINE $2E9F;
  623.     {$ENDC}
  624.  
  625. FUNCTION CallPCCardCSClientProc(ccPBPtr: ClientCallbackPBPtr; userRoutine: PCCardCSClientUPP): UInt16;
  626.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  627.     INLINE $205F, $4E90;
  628.     {$ENDC}
  629.  
  630. TYPE
  631.     RegisterClientPBPtr = ^RegisterClientPB;
  632.     RegisterClientPB = RECORD
  633.         clientHandle:            UInt32;                                    {  <-  client descriptor }
  634.         clientEntry:            PCCardCSClientUPP;                        {   -> universal procPtr to client's event handler }
  635.         attributes:                UInt16;                                    {   -> bitmap of client attributes }
  636.         eventMask:                UInt16;                                    {   -> bitmap of events to notify client }
  637.         clientData:                Ptr;                                    {   -> pointer to client's data }
  638.         version:                UInt16;                                    {   -> Card Services version this client expects }
  639.     END;
  640.  
  641. {     ‘attributes’ field values (see GetClientInfo) }
  642. {
  643.       kCSMemoryClient                    = 0x0001,
  644.       kCSIOClient                        = 0x0004,
  645.       kCSShareableCardInsertEvents    = 0x0008,
  646.       kCSExclusiveCardInsertEvents    = 0x0010
  647. }
  648.  
  649.  
  650. { ----------------        CSReleaseConfiguration            ---------------- }
  651.  
  652.     ReleaseConfigurationPBPtr = ^ReleaseConfigurationPB;
  653.     ReleaseConfigurationPB = RECORD
  654.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  655.         socket:                    UInt16;                                    {   ->  }
  656.     END;
  657.  
  658. { ----------------        CSResetCard                        ---------------- }
  659.  
  660.     ResetCardPBPtr = ^ResetCardPB;
  661.     ResetCardPB = RECORD
  662.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  663.         socket:                    UInt16;                                    {   ->  }
  664.         attributes:                UInt16;                                    {   -> xxx }
  665.     END;
  666.  
  667. { ----------------        CSValidateCIS                    ---------------- }
  668.  
  669.     ValidateCISPBPtr = ^ValidateCISPB;
  670.     ValidateCISPB = RECORD
  671.         socket:                    UInt16;                                    {   ->  }
  672.         chains:                    UInt16;                                    {   -> whether link/null tuples should be included }
  673.     END;
  674.  
  675. {
  676.   ----------------        CSRequestIO                        ----------------
  677.   ----------------        CSReleaseIO                        ----------------
  678. }
  679.  
  680.     ReqRelIOPBPtr = ^ReqRelIOPB;
  681.     ReqRelIOPB = RECORD
  682.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  683.         socket:                    UInt16;                                    {   -> socket number }
  684.         reserved:                UInt16;
  685.         basePort1:                UInt16;                                    {     ->    base I/O port for range }
  686.         numPorts1:                SInt8;                                    {     ->    number of ports (e.g., bytes). }
  687.         attributes1:            SInt8;                                    {     ->    attributes }
  688.         basePort2:                UInt16;                                    {     ->    base I/O port for range }
  689.         numPorts2:                SInt8;                                    {     ->    number of ports }
  690.         attributes2:            SInt8;                                    {     ->    attributes }
  691.         ioAddrLines:            SInt8;                                    {     -> number of I/O lines decoded by card }
  692.         reserved1:                SInt8;
  693.     END;
  694.  
  695. { ----------------        CSVendorSpecific                ---------------- }
  696.     VendorSpecificPBPtr = ^VendorSpecificPB;
  697.     VendorSpecificPB = RECORD
  698.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  699.         vsCode:                    UInt16;
  700.         socket:                    UInt16;
  701.         dataLen:                UInt32;                                    {   -> length of buffer pointed to by vsDataPtr }
  702.         vsDataPtr:                Ptr;                                    {   -> Card Services version this client expects }
  703.     END;
  704.  
  705. {     ‘vsCode’ field values }
  706.  
  707.  
  708. CONST
  709.     vsAppleReserved                = $0000;
  710.     vsEjectCard                    = $0001;
  711.     vsGetCardInfo                = $0002;
  712.     vsEnableSocketEvents        = $0003;
  713.     vsGetCardLocationIcon        = $0004;
  714.     vsGetCardLocationText        = $0005;
  715.     vsGetAdapterInfo            = $0006;
  716.  
  717. {
  718.   ///////////////////////////////////////////////////////////////////////////////////////
  719.       GetAdapterInfo parameter block (vendor-specific call #6)
  720. }
  721.  
  722.  
  723. TYPE
  724.     GetAdapterInfoPBPtr = ^GetAdapterInfoPB;
  725.     GetAdapterInfoPB = RECORD
  726.         attributes:                UInt32;                                    {  <-  capabilties of socket's adapter }
  727.         revision:                UInt16;                                    {  <-  id of adapter }
  728.         reserved:                UInt16;                                    {   }
  729.         numVoltEntries:            UInt16;                                    {  <-  number of valid voltage values }
  730.         voltages:                Ptr;                                    {  <-> array of BCD voltage values }
  731.     END;
  732.  
  733. {     ‘attributes’ field values }
  734.  
  735. CONST
  736.     kCSLevelModeInterrupts        = $00000001;
  737.     kCSPulseModeInterrupts        = $00000002;
  738.     kCSProgrammableWindowAddr    = $00000004;
  739.     kCSProgrammableWindowSize    = $00000008;
  740.     kCSSocketSleepPower            = $00000010;
  741.     kCSSoftwareEject            = $00000020;
  742.     kCSLockableSocket            = $00000040;
  743.     kCSInUseIndicator            = $00000080;
  744.  
  745. {
  746.   ///////////////////////////////////////////////////////////////////////////////////////
  747.       GetCardInfo parameter block (vendor-specific call #2)
  748. }
  749.  
  750.  
  751. TYPE
  752.     GetCardInfoPBPtr = ^GetCardInfoPB;
  753.     GetCardInfoPB = RECORD
  754.         cardType:                SInt8;                                    {  <-  type of card in this socket (defined at top of file) }
  755.         subType:                SInt8;                                    {  <-  more detailed card type (defined at top of file) }
  756.         reserved:                UInt16;                                    {  <-> reserved (should be set to zero) }
  757.         cardNameLen:            UInt16;                                    {   -> maximum length of card name to be returned }
  758.         vendorNameLen:            UInt16;                                    {   -> maximum length of vendor name to be returned }
  759.         cardName:                Ptr;                                    {   -> pointer to card name string (read from CIS), or nil }
  760.         vendorName:                Ptr;                                    {   -> pointer to vendor name string (read from CIS), or nil }
  761.     END;
  762.  
  763. {     GetCardInfo card types }
  764.  
  765. CONST
  766.     kCSUnknownCardType            = 0;
  767.     kCSMultiFunctionCardType    = 1;
  768.     kCSMemoryCardType            = 2;
  769.     kCSSerialPortCardType        = 3;
  770.     kCSSerialOnlyType            = 0;
  771.     kCSDataModemType            = 1;
  772.     kCSFaxModemType                = 2;
  773.     kCSFaxAndDataModemMask        = 3;
  774.     kCSVoiceEncodingType        = 4;
  775.     kCSParallelPortCardType        = 4;
  776.     kCSFixedDiskCardType        = 5;
  777.     kCSUnknownFixedDiskType        = 0;
  778.     kCSATAInterface                = 1;
  779.     kCSRotatingDevice            = $00;
  780.     kCSSiliconDevice            = $80;
  781.     kCSVideoAdaptorCardType        = 6;
  782.     kCSNetworkAdaptorCardType    = 7;
  783.     kCSAIMSCardType                = 8;
  784.     kCSNumCardTypes                = 9;
  785.  
  786.  
  787. {$IFC UNDEFINED __PCCARDENABLERPLUGIN__ }
  788. {
  789.     NOTE: These prototypes conflict with PCCardEnablerPlugin.≈
  790.           You cannot use both PCCardEnablerPlugin.h and CardServices.h
  791.           
  792. }
  793. FUNCTION CSVendorSpecific(VAR pb: VendorSpecificPB): OSErr;
  794.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  795.     INLINE $7000, $AAF0;
  796.     {$ENDC}
  797. FUNCTION CSRegisterClient(VAR pb: RegisterClientPB): OSErr;
  798.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  799.     INLINE $7001, $AAF0;
  800.     {$ENDC}
  801. FUNCTION CSDeregisterClient(VAR pb: RegisterClientPB): OSErr;
  802.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  803.     INLINE $7002, $AAF0;
  804.     {$ENDC}
  805. FUNCTION CSGetFirstTuple(VAR pb: GetTuplePB): OSErr;
  806.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  807.     INLINE $7003, $AAF0;
  808.     {$ENDC}
  809. FUNCTION CSGetNextTuple(VAR pb: GetTuplePB): OSErr;
  810.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  811.     INLINE $7004, $AAF0;
  812.     {$ENDC}
  813. FUNCTION CSGetTupleData(VAR pb: GetTuplePB): OSErr;
  814.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  815.     INLINE $7005, $AAF0;
  816.     {$ENDC}
  817. FUNCTION CSGetConfigurationInfo(VAR pb: GetModRequestConfigInfoPB): OSErr;
  818.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  819.     INLINE $7006, $AAF0;
  820.     {$ENDC}
  821. FUNCTION CSGetCardServicesInfo(VAR pb: GetCardServicesInfoPB): OSErr;
  822.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  823.     INLINE $7007, $AAF0;
  824.     {$ENDC}
  825. FUNCTION CSGetStatus(VAR pb: GetStatusPB): OSErr;
  826.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  827.     INLINE $7008, $AAF0;
  828.     {$ENDC}
  829. FUNCTION CSValidateCIS(VAR pb: ValidateCISPB): OSErr;
  830.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  831.     INLINE $7009, $AAF0;
  832.     {$ENDC}
  833. FUNCTION CSGetFirstClient(VAR pb: GetClientPB): OSErr;
  834.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  835.     INLINE $700F, $AAF0;
  836.     {$ENDC}
  837. FUNCTION CSGetNextClient(VAR pb: GetClientPB): OSErr;
  838.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  839.     INLINE $7010, $AAF0;
  840.     {$ENDC}
  841. FUNCTION CSGetClientInfo(VAR pb: GetClientInfoPB): OSErr;
  842.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  843.     INLINE $7011, $AAF0;
  844.     {$ENDC}
  845. FUNCTION CSResetCard(VAR pb: ResetCardPB): OSErr;
  846.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  847.     INLINE $7012, $AAF0;
  848.     {$ENDC}
  849. FUNCTION CSRequestWindow(VAR pb: ReqModRelWindowPB): OSErr;
  850.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  851.     INLINE $7013, $AAF0;
  852.     {$ENDC}
  853. FUNCTION CSModifyWindow(VAR pb: ReqModRelWindowPB): OSErr;
  854.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  855.     INLINE $7014, $AAF0;
  856.     {$ENDC}
  857. FUNCTION CSReleaseWindow(VAR pb: ReqModRelWindowPB): OSErr;
  858.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  859.     INLINE $7015, $AAF0;
  860.     {$ENDC}
  861. FUNCTION CSRequestConfiguration(VAR pb: GetModRequestConfigInfoPB): OSErr;
  862.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  863.     INLINE $701B, $AAF0;
  864.     {$ENDC}
  865. FUNCTION CSModifyConfiguration(VAR pb: GetModRequestConfigInfoPB): OSErr;
  866.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  867.     INLINE $701C, $AAF0;
  868.     {$ENDC}
  869. FUNCTION CSAccessConfigurationRegister(VAR pb: AccessConfigurationRegisterPB): OSErr;
  870.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  871.     INLINE $701D, $AAF0;
  872.     {$ENDC}
  873. FUNCTION CSReleaseConfiguration(VAR pb: ReleaseConfigurationPB): OSErr;
  874.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  875.     INLINE $701E, $AAF0;
  876.     {$ENDC}
  877. FUNCTION CSGetClientEventMask(VAR pb: GetSetClientEventMaskPB): OSErr;
  878.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  879.     INLINE $701F, $AAF0;
  880.     {$ENDC}
  881. FUNCTION CSSetClientEventMask(VAR pb: GetSetClientEventMaskPB): OSErr;
  882.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  883.     INLINE $7020, $AAF0;
  884.     {$ENDC}
  885. FUNCTION CSRequestSocketMask(VAR pb: ReqRelSocketMaskPB): OSErr;
  886.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  887.     INLINE $7021, $AAF0;
  888.     {$ENDC}
  889. FUNCTION CSReleaseSocketMask(VAR pb: ReqRelSocketMaskPB): OSErr;
  890.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  891.     INLINE $7022, $AAF0;
  892.     {$ENDC}
  893.  
  894. {
  895.       Additional calls which are required for all I/O clients when running on
  896.       systems which do not reserve dedicated I/O-spaces for each PC Card.
  897. }
  898.  
  899. FUNCTION CSRequestIO(VAR pb: ReqRelIOPB): OSErr;
  900.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  901.     INLINE $7025, $AAF0;
  902.     {$ENDC}
  903. FUNCTION CSReleaseIO(VAR pb: ReqRelIOPB): OSErr;
  904.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  905.     INLINE $7026, $AAF0;
  906.     {$ENDC}
  907. {$ENDC}
  908.  
  909. {$ALIGN RESET}
  910. {$POP}
  911.  
  912. {$SETC UsingIncludes := CardServicesIncludes}
  913.  
  914. {$ENDC} {__CARDSERVICES__}
  915.  
  916. {$IFC NOT UsingIncludes}
  917.  END.
  918. {$ENDC}
  919.